package de.akabahn.ebd.stw.zdxfc.prs;

import static de.akabahn.ebd.stw.zdxfc.prs.ZDXFCConstants.*;

import javax.sound.sampled.Clip;

import de.akabahn.ebd.comm.dbd.DBDParameter;
import de.akabahn.ebd.dbd.DBDAdapter;
import de.akabahn.ebd.dbd.DBDSubscriptionListener;
import de.akabahn.ebd.dbd.impl.DBDSignalF;
import de.akabahn.ebd.stw.zdxfc.prs.elemente.Gleis;
import de.akabahn.ebd.stw.zdxfc.prs.elemente.Signal;
import de.akabahn.ebd.stw.zdxfc.prs.elemente.Weiche;
import de.akabahn.ebd.stw.zdxfc.prs.fst.FahrStrasse;
import de.akabahn.ebd.stw.zdxfc.prs.fst.impair.FahrStrasseEC;
import de.akabahn.ebd.stw.zdxfc.prs.fst.impair.FahrStrasseFB;
import de.akabahn.ebd.stw.zdxfc.prs.fst.impair.FahrStrasseFD;
import de.akabahn.ebd.stw.zdxfc.prs.fst.impair.FahrStrasseGB;
import de.akabahn.ebd.stw.zdxfc.prs.fst.impair.FahrStrasseHB;
import de.akabahn.ebd.stw.zdxfc.prs.fst.impair.FahrStrasseHC;
import de.akabahn.ebd.stw.zdxfc.prs.fst.impair.FahrStrasseIB;
import de.akabahn.ebd.stw.zdxfc.prs.fst.impair.FahrStrasseIC;
import de.akabahn.ebd.stw.zdxfc.prs.fst.impair.FahrStrasseJB;
import de.akabahn.ebd.stw.zdxfc.prs.fst.impair.FahrStrasseJC;
import de.akabahn.ebd.stw.zdxfc.prs.fst.impair.FahrStrasseLF;
import de.akabahn.ebd.stw.zdxfc.prs.fst.impair.FahrStrasseMF;
import de.akabahn.ebd.stw.zdxfc.prs.fst.impair.FahrStrasseMG;
import de.akabahn.ebd.stw.zdxfc.prs.fst.impair.FahrStrasseMH;
import de.akabahn.ebd.stw.zdxfc.prs.fst.impair.FahrStrasseMK;
import de.akabahn.ebd.stw.zdxfc.prs.fst.impair.FahrStrasseNH;
import de.akabahn.ebd.stw.zdxfc.prs.fst.impair.FahrStrasseNK;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseAF;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseAG;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseAH;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseAI;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseAJ;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseBF;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseBG;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseBH;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseBI;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseBJ;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseCE;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseCH;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseCI;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseCJ;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseDF;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseFL;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseFM;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseGM;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseHM;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseHN;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseKM;
import de.akabahn.ebd.stw.zdxfc.prs.fst.pair.FahrStrasseKN;
import de.akabahn.ebd.stw.zdxfc.prs.fst.tp.FahrStrasseECCE;

/**
 * Initialisierung des Stellwerks (beim Hochfahren und Restarten), Setzen der verwendeten
 * DBD-Variablen in den Grundzustand, Abonnieren der zu lesenden DBD-Variablen, Erstellung
 * aller verwendeten Elemente
 * 
 * @author Peter Eimann
 * @since 1.0
 * @version 1.2
 * @see DBDSubscriptionListener
 */
public class ZDXFCInitializer {

	private ZDXFCMain main;
	private DBDSubscriptionListener listener;

	/**
	 * Initialisierung der Klasse
	 * 
	 * @param main Referenz auf die Hauptklasse
	 * @param listener Die DBD-Subscription Implementierung zum Abonnieren der Variablen
	 */
	public ZDXFCInitializer(ZDXFCMain main, DBDSubscriptionListener listener) {
		this.main = main;
		this.listener = listener;
	}

	/**
	 * Ausfuehrung der Initialisierung
	 * @throws Exception 
	 * 
	 * @see #erstelleWeichen()
	 * @see #erstelleGleise()
	 * @see #erstelleSignale()
	 * @see #erstelleFahrStrassen()
	 * @see #initSignale()
	 * @see #initBlock()
	 * @see #initTastenmelder()
	 * @see #abonniereWeichen()
	 * @see #abonniereGleise()
	 * @see #abonniereSchalter()
	 * @see #abonniereTasten()
	 * @see #abonniereBlock()
	 * @see #abonniereHilfshandlungen()
	 * @see #abonniereSperre()
	 * @see #loadClip(String, Clip)
	 */
	public void initialize() throws Exception {
		erstelleWeichen();
		erstelleGleise();
		erstelleSignale();
		erstelleFahrStrassen();

		initSignale();
		initBlock();
		initTastenmelder();

		abonniereWeichen();
		abonniereGleise();
		abonniereSchalter();
		abonniereTasten();
		abonniereBlock();

		abonniereHilfshandlungen();
		abonniereSperre();
	}

	/**
	 * Erstellung der verwendeten Weichen
	 * @see Weiche
	 * @see ZDXFCMain#addWeiche(Weiche)
	 */
	private void erstelleWeichen() {
		main.addWeiche(new Weiche(WEICHE_1, MELDER_WEICHE_1, main));
		main.addWeiche(new Weiche(WEICHE_2, MELDER_WEICHE_2, main));
		main.addWeiche(new Weiche(WEICHE_3, MELDER_WEICHE_3, main));
		main.addWeiche(new Weiche(WEICHE_4, MELDER_WEICHE_4, main));
		main.addWeiche(new Weiche(WEICHE_5, MELDER_WEICHE_5, main));
		main.addWeiche(new Weiche(WEICHE_6, MELDER_WEICHE_6, main));
		main.addWeiche(new Weiche(WEICHE_7, MELDER_WEICHE_7, main));
		main.addWeiche(new Weiche(WEICHE_8, MELDER_WEICHE_8, main));
		main.addWeiche(new Weiche(WEICHE_9, MELDER_WEICHE_9, main));
		main.addWeiche(new Weiche(WEICHE_10, MELDER_WEICHE_10, main));
		main.addWeiche(new Weiche(WEICHE_110, MELDER_WEICHE_110, main));
		main.addWeiche(new Weiche(WEICHE_12, MELDER_WEICHE_12, main));
	}

	/**
	 * Erstellung der verwendeten Gleise<br>
	 * Steuerung des Verschlusses der Einfahrstrassen auf Signal C2 bei Besetzung des Streckenabschnitts
	 * zwischen Martinstein und Chateauprix<br>
	 * Steuerung der Blockschnittstelle zwischen Chateauprix und Martinstein bei Belegung und Freifahren des
	 * Streckenabschnitts zwischen Martinstein und Chateauprix
	 * 
	 * @see Gleis
	 * @see ZDXFCMain#addGleis(Gleis)
	 */
	private void erstelleGleise() {
		main.addGleis(new Gleis(GLEIS_1, MELDER_GLEIS_1, main));
		main.addGleis(new Gleis(GLEIS_102, MELDER_GLEIS_102, main));
		main.addGleis(new Gleis(GLEIS_11, MELDER_GLEIS_11, main));
		main.addGleis(new Gleis(GLEIS_12, MELDER_GLEIS_12, main));
		main.addGleis(new Gleis(GLEIS_13, MELDER_GLEIS_13, main));
		main.addGleis(new Gleis(GLEIS_14, MELDER_GLEIS_14, main));
		main.addGleis(new Gleis(GLEIS_1BIS, MELDER_GLEIS_1BIS, main));
		main.addGleis(new Gleis(GLEIS_2, MELDER_GLEIS_2, main));
		main.addGleis(new Gleis(GLEIS_2BIS, MELDER_GLEIS_2BIS, main));
		main.addGleis(new Gleis(GLEIS_2TER, MELDER_GLEIS_2TER, main));
		main.addGleis(new Gleis(STRECKE_1231, MELDER_STRECKE_1231, main) {
			@Override
			public void onChangePostProcess(DBDParameter dbd) {
				if (dbd.getId().equals(id)) {
					if (isBesetzt()) {
						main.getBlock1231().streckenGleisBesetzt();
						if (main.getFahrStrasse(FAHRSTRASSE_AF).isAktiv()) {
							main.getFahrStrasse(FAHRSTRASSE_AF).setVerschlossen(true);
						} else if (main.getFahrStrasse(FAHRSTRASSE_AG).isAktiv()) {
							main.getFahrStrasse(FAHRSTRASSE_AG).setVerschlossen(true);
						} else if (main.getFahrStrasse(FAHRSTRASSE_AH).isAktiv()) {
							main.getFahrStrasse(FAHRSTRASSE_AH).setVerschlossen(true);
						} else if (main.getFahrStrasse(FAHRSTRASSE_AI).isAktiv()) {
							main.getFahrStrasse(FAHRSTRASSE_AI).setVerschlossen(true);
						} else if (main.getFahrStrasse(FAHRSTRASSE_AJ).isAktiv()) {
							main.getFahrStrasse(FAHRSTRASSE_AJ).setVerschlossen(true);
						} else {
							if (!main.getGleis(GLEIS_102).isBesetzt()) {
								main.getDbd().set(MELDER_SIGNAL_C2[VERSCHLUSS], BIT1);
							}
						}
						main.getDbd().set(BLOCK_1231_MELDER_AN, 0);
					} else {
						main.getBlock1231().streckenGleisFrei();
					}
				}
			}
		});
	}

	/**
	 * Erstellung der verwendeten Signale.<br>
	 * Bei den Signalen <code>C1</code>, <code>C3</code> und <code>CV5</code>
	 * wird zusaetzlich noch die <code>onChangeHauptsignal(Signal)</code> Methode ueberschrieben, damit diese das
	 * richtige Vorsignalbild zum Hauptsignal (Semaphore <code>S4880</code>) anzeigen.
	 * 
	 * @see Signal
	 * @see Signal#onChangeHauptsignal(Signal)
	 * @see ZDXFCMain#addSignal(Signal)
	 */
	private void erstelleSignale() {
		main.addSignal(new Signal(SIGNAL_C1, MELDER_SIGNAL_C1, DBDSignalF.C, main) {
			@Override
			public void onChangeHauptsignal(Signal hauptSignal) {
				super.onChangeHauptsignal(hauptSignal);
				if (hauptSignal.getSignalBegriff() == DBDSignalF.VL) {
					stellen(DBDSignalF.VL);
				} else {
					stellen(DBDSignalF.ASP);
				}
			}
		});
		main.addSignal(new Signal(SIGNAL_C2, MELDER_SIGNAL_C2, DBDSignalF.C, main));
		main.addSignal(new Signal(SIGNAL_C2V, MELDER_SIGNAL_C2V, DBDSignalF.AAP, main) {
			@Override
			public void onChangeHauptsignal(Signal hauptSignal) {
				super.onChangeHauptsignal(hauptSignal);
				if (hauptSignal.getSignalBegriff() == DBDSignalF.AAP) {
					stellen(DBDSignalF.VL);
				} else if (hauptSignal.getSignalBegriff() == DBDSignalF.RRC_A) {
					stellen(DBDSignalF.RC);
				} else if (hauptSignal.getSignalBegriff() == DBDSignalF.RR_A) {
					stellen(DBDSignalF.R);
				} else {
					stellen(DBDSignalF.AAP);
				}
			}
		});
		main.addSignal(new Signal(SIGNAL_C3, MELDER_SIGNAL_C3, DBDSignalF.C, main) {
			@Override
			public void onChangeHauptsignal(Signal hauptSignal) {
				super.onChangeHauptsignal(hauptSignal);
				if (hauptSignal.getSignalBegriff() == DBDSignalF.VL) {
					stellen(DBDSignalF.VL);
				} else {
					stellen(DBDSignalF.ASP);
				}
			}
		});
		main.addSignal(new Signal(SIGNAL_CV4, MELDER_SIGNAL_CV4, DBDSignalF.CV, main));
		main.addSignal(new Signal(SIGNAL_CV51, MELDER_SIGNAL_CV5, DBDSignalF.C, main) {
			@Override
			public void onChangeHauptsignal(Signal hauptSignal) {
				super.onChangeHauptsignal(hauptSignal);
				if (hauptSignal.getSignalBegriff() == DBDSignalF.VL) {
					stellen(DBDSignalF.VL);
				} else {
					stellen(DBDSignalF.ASP);
				}
			}
		});
		main.addSignal(new Signal(SIGNAL_CV52, MELDER_SIGNAL_CV5, DBDSignalF.C, main) {
			@Override
			public void onChangeHauptsignal(Signal hauptSignal) {
				super.onChangeHauptsignal(hauptSignal);
				if (hauptSignal.getSignalBegriff() == DBDSignalF.VL) {
					stellen(DBDSignalF.VL);
				} else {
					stellen(DBDSignalF.ASP);
				}
			}
		});
		main.addSignal(new Signal(SIGNAL_CV53, MELDER_SIGNAL_CV5, DBDSignalF.C, main) {
			@Override
			public void onChangeHauptsignal(Signal hauptSignal) {
				super.onChangeHauptsignal(hauptSignal);
				if (hauptSignal.getSignalBegriff() == DBDSignalF.VL) {
					stellen(DBDSignalF.VL);
				} else {
					stellen(DBDSignalF.ASP);
				}
			}
		});
		main.addSignal(new Signal(SIGNAL_CV6, MELDER_SIGNAL_CV6, DBDSignalF.CV, main));
		main.addSignal(new Signal(SIGNAL_CV7, MELDER_SIGNAL_CV7, DBDSignalF.CV, main));
		main.addSignal(new Signal(SIGNAL_C8, MELDER_SIGNAL_C8, DBDSignalF.C, main));
		main.addSignal(new Signal(SIGNAL_CV9, MELDER_SIGNAL_CV9, DBDSignalF.CV, main));
		main.addSignal(new Signal(SIGNAL_C10, MELDER_SIGNAL_C10, DBDSignalF.C, main));
		main.addSignal(new Signal(SIGNAL_CV11, MELDER_SIGNAL_CV11, DBDSignalF.CV, main));
		main.addSignal(new Signal(SIGNAL_CV121, MELDER_SIGNAL_CV12, DBDSignalF.CV, main));
		main.addSignal(new Signal(SIGNAL_CV122, MELDER_SIGNAL_CV12, DBDSignalF.CV, main));
		main.addSignal(new Signal(SIGNAL_CV123, MELDER_SIGNAL_CV12, DBDSignalF.CV, main));
		main.addSignal(new Signal(SIGNAL_CV13, MELDER_SIGNAL_CV13, DBDSignalF.CV, main));
		main.addSignal(new Signal(SIGNAL_CV14, MELDER_SIGNAL_CV14, DBDSignalF.CV, main));
		main.addSignal(new Signal(SIGNAL_S4880, MELDER_SIGNAL_S4880, DBDSignalF.S_BM, main));
	}

	/**
	 * Erstellung der verwendeten Fahrstrassen
	 * @see FahrStrasse
	 * @see ZDXFCMain#addFahrStrasse(FahrStrasse)
	 */
	private void erstelleFahrStrassen() {
		// Sens Pair
		main.addFahrStrasse(new FahrStrasseAF(main));
		main.addFahrStrasse(new FahrStrasseAG(main));
		main.addFahrStrasse(new FahrStrasseAH(main));
		main.addFahrStrasse(new FahrStrasseAI(main));
		main.addFahrStrasse(new FahrStrasseAJ(main));
		main.addFahrStrasse(new FahrStrasseBF(main));
		main.addFahrStrasse(new FahrStrasseBG(main));
		main.addFahrStrasse(new FahrStrasseBH(main));
		main.addFahrStrasse(new FahrStrasseBI(main));
		main.addFahrStrasse(new FahrStrasseBJ(main));
		main.addFahrStrasse(new FahrStrasseCE(main));
		main.addFahrStrasse(new FahrStrasseCH(main));
		main.addFahrStrasse(new FahrStrasseCI(main));
		main.addFahrStrasse(new FahrStrasseCJ(main));
		main.addFahrStrasse(new FahrStrasseDF(main));
		main.addFahrStrasse(new FahrStrasseFL(main));
		main.addFahrStrasse(new FahrStrasseFM(main));
		main.addFahrStrasse(new FahrStrasseGM(main));
		main.addFahrStrasse(new FahrStrasseHM(main));
		main.addFahrStrasse(new FahrStrasseHN(main));
		main.addFahrStrasse(new FahrStrasseKM(main));
		main.addFahrStrasse(new FahrStrasseKN(main));

		// Sens Impair
		main.addFahrStrasse(new FahrStrasseEC(main));
		main.addFahrStrasse(new FahrStrasseFB(main));
		main.addFahrStrasse(new FahrStrasseFD(main));
		main.addFahrStrasse(new FahrStrasseGB(main));
		main.addFahrStrasse(new FahrStrasseHB(main));
		main.addFahrStrasse(new FahrStrasseHC(main));
		main.addFahrStrasse(new FahrStrasseIB(main));
		main.addFahrStrasse(new FahrStrasseIC(main));
		main.addFahrStrasse(new FahrStrasseJB(main));
		main.addFahrStrasse(new FahrStrasseJC(main));
		main.addFahrStrasse(new FahrStrasseLF(main));
		main.addFahrStrasse(new FahrStrasseMF(main));
		main.addFahrStrasse(new FahrStrasseMG(main));
		main.addFahrStrasse(new FahrStrasseMH(main));
		main.addFahrStrasse(new FahrStrasseMK(main));
		main.addFahrStrasse(new FahrStrasseNH(main));
		main.addFahrStrasse(new FahrStrasseNK(main));

		// Trasse Permanente
		main.addFahrStrasse(new FahrStrasseECCE(main));
	}

	/**
	 * Initialisiere alle verwendeten Signale
	 * @see Signal#init()
	 */
	private void initSignale() {
		for (String signalId : main.getSignale().keySet()) {
			main.getSignal(signalId).init();
		}
		main.getSignal(SIGNAL_C2).setVorsignal(main.getSignal(SIGNAL_C2V));
	}

	/**
	 * Initialisiere die Blockschnittstelle zwischen Martinstein und Chateauprix
	 */
	private void initBlock() {
		main.getDbd().set(BLOCK_1231_MELDER_VL, BIT0);
	}
	
	/**
	 * Initialisiere alle Tastenmelder
	 */
	private void initTastenmelder() {
		for (String fahrstrassenId : main.getFahrStrassen().keySet()) {
			main.getDbd().set(TASTE_PREFIX + fahrstrassenId + "S", 0);
		}

		main.getDbd().set(MELDER_TASTE_BLOCK1231_ANN, 0);
		main.getDbd().set(MELDER_TASTE_BLOCK1231_RED, 0);
		main.getDbd().set(MELDER_TASTE_BLOCK1231_SN, 0);
		main.getDbd().set(MELDER_TASTE_BLOCK1231_TEST, 0);
		main.getDbd().set(MELDER_TASTE_TEST_AIG, 0);
		main.getDbd().set(MELDER_TASTE_TEST_ZONES, 0);
	}
	
	/**
	 * Abonniere die verwendeten Weichen (Istlage und Besetztmeldung)
	 * @see DBDAdapter#subscribe(String, DBDSubscriptionListener)
	 */
	private void abonniereWeichen() {
		for (String weichenId : main.getWeichen().keySet()) {
			main.getDbd().subscribe(weichenId + "I", listener);
			main.getDbd().subscribe(weichenId + "B", listener);
		}
	}

	/**
	 * Abonniere die verwendeten Gleise (Besetztmeldung)
	 * @see DBDAdapter#subscribe(String, DBDSubscriptionListener)
	 */
	private void abonniereGleise() {
		for (String gleisId : main.getGleise().keySet()) {
			main.getDbd().subscribe(gleisId + "B", listener);
		}
	}

	/**
	 * Abonniere die verwendeten Schalter
	 * @see DBDAdapter#subscribe(String, DBDSubscriptionListener)
	 */
	private void abonniereSchalter() {
		main.getDbd().subscribe(SCHALTER_C1, listener);
		main.getDbd().subscribe(SCHALTER_C2, listener);
		main.getDbd().subscribe(SCHALTER_C3, listener);
		main.getDbd().subscribe(SCHALTER_CV4, listener);
		main.getDbd().subscribe(SCHALTER_CV5, listener);
		main.getDbd().subscribe(SCHALTER_CV6, listener);
		main.getDbd().subscribe(SCHALTER_CV7, listener);
		main.getDbd().subscribe(SCHALTER_C8, listener);
		main.getDbd().subscribe(SCHALTER_CV9, listener);
		main.getDbd().subscribe(SCHALTER_C10, listener);
		main.getDbd().subscribe(SCHALTER_CV11, listener);
		main.getDbd().subscribe(SCHALTER_CV12, listener);
		main.getDbd().subscribe(SCHALTER_CV13, listener);
		main.getDbd().subscribe(SCHALTER_CV14, listener);
		main.getDbd().subscribe(SCHALTER_BLOCK1231_BLOC, listener);
		main.getDbd().subscribe(SCHALTER_S4880, listener);
	}
	
	/**
	 * Abonniere die verwendeten Tasten
	 * @see DBDAdapter#subscribe(String, DBDSubscriptionListener)
	 */
	private void abonniereTasten() {
		for (String fahrstrassenId : main.getFahrStrassen().keySet()) {
			main.getDbd().subscribe(TASTE_PREFIX + fahrstrassenId + "I", listener);
		}

		main.getDbd().subscribe(TASTE_BLOCK1231_ANN, listener);
		main.getDbd().subscribe(TASTE_BLOCK1231_RED, listener);
		main.getDbd().subscribe(TASTE_BLOCK1231_SN, listener);
		main.getDbd().subscribe(TASTE_BLOCK1231_TEST, listener);
		main.getDbd().subscribe(TASTE_TEST_AIG, listener);
		main.getDbd().subscribe(TASTE_TEST_ZONES, listener);
	}
	
	/**
	 * Abonniere die Blockschnittstelle zwischen Martinstein und Chateauprix und die Elemente in Martinstein,
	 * um das Aufleuchten der Annonce-Lampe zu steuern
	 * @see DBDAdapter#subscribe(String, DBDSubscriptionListener)
	 */
	private void abonniereBlock() {
		main.getDbd().subscribe(BLOCK_1231_ZDM, listener);
		main.getDbd().subscribe("12P5S", listener);
		main.getDbd().subscribe("12P6S", listener);
		main.getDbd().subscribe("12P7S", listener);
		main.getDbd().subscribe("12W18I", listener);
		main.getDbd().subscribe("12W19I", listener);
		main.getDbd().subscribe("12W21I", listener);
	}
	
	/**
	 * Abonniere die moeglichen Hilfshandlungen (nicht vom Pult aus bedienbar, nur durch direktes
	 * Setzen der DBD-Variablen mit dem Wert 1 auszuloesen)
	 * @see DBDAdapter#subscribe(String, DBDSubscriptionListener)
	 */
	private void abonniereHilfshandlungen() {
		for (String fahrstrassenId : main.getFahrStrassen().keySet()) {
			main.getDbd().subscribe(HILFSHANDLUNG_PREFIX + fahrstrassenId, listener);
		}
		
		main.getDbd().subscribe(RESET_STELLWERK, listener);
		main.getDbd().subscribe(RESET_BLOCK_1231, listener);
	}

	/**
	 * Abonniere das Sperr-Flag
	 * @see DBDAdapter#subscribe(String, DBDSubscriptionListener)
	 */
	private void abonniereSperre() {
		main.getDbd().subscribe(SPERRE_ZDXFC, listener);
	}
}
